import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.HashSet;
import java.util.Set;

/**
 * Created with IntelliJ IDEA.
 * Description: 牛客网: 两个有序数组间相加和的Topk问题
 * <a href="https://www.nowcoder.com/practice/7201cacf73e7495aa5f88b223bbbf6d1">...</a>
 * User: DELL
 * Date: 2023-08-22
 * Time: 22:20
 */


/**
 * 解题思路: (堆 + 哈希)
 * 首先解题题目已经明确了,提供的两个数组均为有序数组,因此不需要再进行排序.
 * 之后我们可以这样子想象,即想象一个 N*N 的二维数组 ans ,其中的每一个元
 * 素 (i,j) 为 (arr1[i] + arr2[j]),那么肯定有如下结论,即
 * ans[i][j] >= ans[i-1][j] >= ans[i-1][j-1]
 * ans[i][j] >= ans[i][j-1] >= ans[i-1][j-1]
 * 即每一个元素比起小且与其值最接近的两个一定是左边和上边的元素,那么我们可以
 * 这样子,首先使用一个大根堆来记录右下角的元素,且大根堆中存的节点记录这个元素
 * 的值和其横纵坐标,然后每次都从大根堆中取出堆顶元素,然后将取出元素的左边和右
 * 边的元素存入大根堆中,知道总共从大根堆中取出 K 个元素即可.
 * 上面的处理之中有一个很严重的问题就是相同的元素可能被重复添加,这显然不合理,
 * 因此这里使用一个 HashSet 来处理,首先依据每一个添加进入大根堆中的元素,
 * 依据其横纵坐标生成一个特定的值,然后将这个值存入 HashSet 中,之后的每次向
 * 大根堆中添加元素的时候,均判断以下依据特定横纵坐标生成的值是否已经再 HashSet
 * 中了,依据这个来避免重复添加元素.
 *
 * 总体来说上述方法就是采用动态规划的思想,然后使用大根堆筛选最大值,使用 HashSet 来避免
 * 重复添加元素,较为复杂.
 */
public class Main {

    /**
     * 大根堆中存入的元组
     */
    static class Node{
        public int a;
        public int b;
        public int sum;
        public Node(int a,int b,int sum){
            this.a = a;
            this.b = b;
            this.sum = sum;
        }
    }

    /**
     * 根据数组的下标生成一个唯一的 int 值,方便
     * 判断该下标的元素是否已经添加过.
     * @param a
     * @param b
     * @param cols
     * @return
     */
    static int uniqueCode(int a,int b,int cols){
        return a*cols + b;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int K = scanner.nextInt();
        int[] arr1 = new int[N];
        int[] arr2 = new int[N];
        for (int i = 0; i < N; i++) {
            arr1[i] = scanner.nextInt();
        }
        for (int i = 0; i < N; i++) {
            arr2[i] = scanner.nextInt();
        }
        // 使用大根堆来找最大值
        PriorityQueue<Node> bigHeap = new PriorityQueue<Node>((o1,o2)->{ return o2.sum - o1.sum;});
        // 使用 HashSet 来判断元素是否已经添加过
        Set<Integer> isVisited = new HashSet<>();
        // 已选取的元素数目
        int count = 0;
        // 记录结果的数组
        int[] ans = new int[K];
        int a = N-1;
        int b = N - 1;
        bigHeap.add(new Node(a,b,arr1[a] + arr2[b]));
        isVisited.add(uniqueCode(a,b,N));
        while(count < K){
            Node node = bigHeap.poll();
            ans[count++] = node.sum;
            a = node.a;
            b = node.b;
            // 移除掉是避免内存溢出
            isVisited.remove(uniqueCode(a,b,N));
            // 若上面和左边的元素是否合法且未加入,则加入
            if( a-1 >= 0 && !isVisited.contains(uniqueCode(a-1,b,N)) ){
                isVisited.add(uniqueCode(a-1,b,N));
                bigHeap.add(new Node(a-1,b,arr1[a-1] + arr2[b]));
            }
            if( b-1 >= 0 && !isVisited.contains(uniqueCode(a,b-1,N)) ){
                isVisited.add(uniqueCode(a,b-1,N));
                bigHeap.add(new Node(a,b-1,arr1[a] + arr2[b-1]));
            }
        }
        // 打印结果
        for (int i = 0; i < count; i++) {
            System.out.print(ans[i] + " ");
        }
    }
}


